Back to: Python Tutorials For Beginners and Professionals

In this article, I am going to discuss Types of Function Arguments in Python with Examples. Please read our previous article where we discussed Functions in Python with examples. At the end of this article, you will understand the following pointers in detail which are related to python Function Arguments.

Argument: An argument is a variable (which contains data) or a parameter that is sent to the function as input. Before getting into argument types, let’s get familiar with words formal and actual arguments.

Output: 25

In python, depending on the way or format we send the arguments to the function, the arguments can be classified into four types:

If there are three arguments (formal arguments) in the function definition, then you need to send three arguments(actual arguments) while calling the function. The actual arguments will be received by the formal arguments in the same order as in the function call. Let’s understand this through an example.

In demo16.py the actual arguments 10, 20 will be received in the same order sent i.e 10 will go into variable ‘x’, and 20 will go into the variable ‘y’. If we send the arguments as 20,10 then 20 will go into x and 10 will go into y. The number of arguments and position of arguments should be matched, otherwise, we will get errors as shown in demo17.py

Output: -10

Output: TypeError: sub() takes 2 positional arguments but 3 were given

In the function call, if we send the values using keys then they are called keyword arguments. Here, keys are nothing but the names of the variables. In a way, we can say that keyword arguments are arguments that recognize the parameters by the name of the parameters. Let’s understand it by the example demo18.py where the name of the function is cart() and parameters are item and price can be written as:

def cart(item, price):

At the time of calling this function, we must pass two values and we can write which value is for what by using the name of the parameter, for example,

cart(item=”bangles”, price=20000) cart(item=”handbag”, price=100000)

item and price are called keywords in this scenario. Here we can change the order of arguments.

Note: We can use both positional and keyword arguments simultaneously. But first, we must take positional arguments and then keyword arguments, otherwise, we will get syntax errors as shown in demo21.py

Output: SyntaxError: non-keyword arg after keyword arg

In the function definition, while declaring parameters, we can assign some value to the parameters, which are called default values. Such default values will be considered when the function call does not send any data to the parameter. Let’s take the function from demo18.py as an example. There, the function cart has parameters as items and price. Let’s say the price of many items is 20 rupees. In this case, we can set the price param to the default value of 20 rupees

def cart(items, price=20):

In the above example items have no default value, so we should provide. price has a default value of 20. Still, if we provide the value at the time of calling then default values will be overridden with passed value.

Note: If we are not passing any value, then only the default value will be considered. While defining a function, after default arguments we should not take non-default arguments.

Output: SyntaxError: non-default argument follows default argument

Sometimes, the programmer does not know how many values need to pass to function. In that case, the programmer cannot decide how many arguments to be given in the function definition. Therefore, we use variable-length arguments to accept n number of arguments.

The variable-length argument is an argument that can accept any number of values. The variable-length argument is written with a ‘*’ (one star) before the variable in the function definition.

x is a formal argument, *y is a variable-length argument. Now we can pass any number of values to this *y. Internally the provided values will be represented in the tuple.

Just as variable length arguments, there are keyword variable length arguments that are n key-value pairs. The syntax is given below.

**x represents as keyword variable argument. Internally it represents a dictionary object. A dictionary stores the data in the form of key-value pairs.

In the next article, I am going to discuss Types of Variables in Python. Here, in this article, I try to explain Function Arguments in Python. I hope you enjoy this Types of Function Arguments in Python with Examples article. I would like to have your feedback. Please post your feedback, question, or comments about this article.